import service from '../require/request';
import {
    StudentSearchParams,
    StudentSearchResponse,
    AddStudentParams,
    AddStudentResponse,
    DeleteStudentParams,
    DeleteStudentResponse,
    UploadStudentFileResponse,
    StudentBaseInfoParams,
    StudentBaseInfo,
    UpdateStudentBaseInfoParams,
    UpdateStudentBaseInfoResponse,
    StudentBackgroundInfoParams,
    StudentBackgroundInfo,
    UpdateStudentBackgroundInfoParams,
    UpdateStudentBackgroundInfoResponse,
    StudentActivityInfoParams,
    StudentActivityInfoResponse,
    UpdateStudentActivityInfoParams,
    UpdateStudentActivityInfoResponse,
    AddStudentActivityInfoParams,
    AddStudentActivityInfoResponse,
    CreateStudentActivityInfoParams,
    CreateStudentActivityInfoResponse,
    DeleteStudentActivityInfoParams,
    DeleteStudentActivityInfoResponse,
    StudentInternshipInfoParams,
    StudentInternshipInfoResponse,
    UpdateStudentInternshipInfoParams,
    UpdateStudentInternshipInfoResponse,
    CreateStudentInternshipInfoParams,
    CreateStudentInternshipInfoResponse,
    DeleteStudentInternshipInfoParams,
    DeleteStudentInternshipInfoResponse,
    StudentOfferInfoParams,
    StudentOfferInfoResponse,
    StudentKeyInfoParams,
    StudentKeyInfo,
    StudentGraduateInfoParams,
    StudentGraduateInfo,
    StudentDailyInfoParams,
    StudentDailyInfoResponse,
    StudentOfferDetailParams,
    StudentOfferDetail,
    DeleteStudentOfferInfoParams,
    DeleteStudentOfferInfoResponse,
    UpdateStudentOfferInfoParams,
    UpdateStudentOfferInfoResponse,
    UpdateStudentKeyInfoParams,
    UpdateStudentKeyInfoResponse,
    SpecialAttentionResponse,
    ParentsContactedResponse,
    ProvinceSystemReportResponse,
    GraduateRegisteReportResponse,
    UpdateStudentGraduateInfoParams,
    UpdateStudentGraduateInfoResponse,
    AddStudentDailyInfoParams,
    AddStudentDailyInfoResponse,
    DeleteStudentDailyInfoParams,
    DeleteStudentDailyInfoResponse,
    UpdateStudentDailyInfoResponse,
    UpdateStudentDailyInfoParams,
    GraduatePlanResponse,
    ChineseLevelResponse,
    OfferStatusResponse,
    OfferTypeResponse,
    DifficultyTypeResponse,
    RecordTypeResponse,
    ProjectTypeResponse,
    EnrollmentStatusResponse,
    EnrollmentTypeResponse,
    AdvisorResponse
} from './types';

/**
 * 学生信息查询
 * @param params 查询参数
 * @returns Promise<StudentSearchResponse>
 */
export const searchStudents = async (params: StudentSearchParams): Promise<StudentSearchResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<StudentSearchResponse, StudentSearchResponse>(
            '/b/sme/cdc/career/main/search',
            params
        );

        return apiData;
    } catch (error) {
        console.error('学生信息查询失败:', error);
        throw error;
    }
};

/**
 * 添加学生信息
 * @param params 学生信息参数
 * @returns Promise<AddStudentResponse>
 */
export const addStudent = async (params: AddStudentParams): Promise<AddStudentResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<AddStudentResponse, AddStudentResponse>(
            '/b/sme/cdc/career/main/add',
            params
        );

        return apiData;
    } catch (error) {
        console.error('添加学生信息失败:', error);
        throw error;
    }
};

/**
 * 删除学生信息
 * @param params 删除参数，包含record_id和uid
 * @returns Promise<DeleteStudentResponse>
 */
export const deleteStudent = async (params: DeleteStudentParams): Promise<DeleteStudentResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<DeleteStudentResponse, DeleteStudentResponse>(
            '/b/sme/cdc/career/main/delete',
            params
        );

        return apiData;
    } catch (error) {
        console.error('删除学生信息失败:', error);
        throw error;
    }
};

/**
 * 上传学生信息文件
 * @param uid 用户ID
 * @param file 文件实体
 * @returns Promise<UploadStudentFileResponse>
 */
export const uploadStudentFile = async (uid: string, file: File): Promise<UploadStudentFileResponse> => {
    try {
        const formData = new FormData();
        formData.append('uid', uid);
        formData.append('file', file);

        const response = await service.post<UploadStudentFileResponse, UploadStudentFileResponse>(
            '/b/sme/cdc/career/main/upload',
            formData,
            {
                headers: {
                    'Content-Type': 'multipart/form-data'
                }
            }
        );

        return response;
    } catch (error) {
        console.error('上传学生信息文件失败:', error);
        throw error;
    }
};

/**
 * 下载学生信息文件
 * @param params 查询参数，与搜索参数一致
 * @returns void
 */
// export const downloadStudentFile = async (params: StudentSearchParams): Promise<void> => {
//     try {
//         // 准备请求参数，去除空值
//         const requestParams: Record<string, any> = {};

//         // 获取当前登录用户ID，这里假设从 localStorage 中获取
//         const uid = localStorage.getItem('uid') || '';
//         requestParams.uid = uid;

//         // 添加其他非空参数
//         Object.entries(params).forEach(([key, value]) => {
//             if (value !== undefined && value !== null && value !== '') {
//                 requestParams[key] = value;
//             }
//         });

//         // 使用 Blob 接收二进制数据
//         const response = await service.post('/b/sme/cdc/career/main/download', requestParams, {
//             responseType: 'blob'
//         });

//         // 使用通用工具函数处理文件下载
//         const defaultFilename = createTimestampedFilename('学生信息', '.xlsx');
//         handleFileDownload(response, defaultFilename);
//     } catch (error) {
//         console.error('下载学生信息文件失败:', error);
//         throw error;
//     }
// };

/**
 * 获取学生详情基础信息
 * @param params 查询参数，包含record_id和uid
 * @returns Promise<StudentBaseInfo>
 */
export const getStudentBaseInfo = async (params: StudentBaseInfoParams): Promise<StudentBaseInfo> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<StudentBaseInfo, StudentBaseInfo>(
            '/b/sme/cdc/career/detail/base_info/search',
            params
        );

        return apiData;
    } catch (error) {
        console.error('获取学生基础信息失败:', error);
        throw error;
    }
};

/**
 * 更新学生详情基础信息
 * @param params 更新参数，包含record_id、sid、base_info_id等字段
 * @returns Promise<UpdateStudentBaseInfoResponse>
 */
export const updateStudentBaseInfo = async (
    params: UpdateStudentBaseInfoParams
): Promise<UpdateStudentBaseInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<UpdateStudentBaseInfoResponse, UpdateStudentBaseInfoResponse>(
            '/b/sme/cdc/career/detail/base_info/update',
            params
        );

        return apiData;
    } catch (error) {
        console.error('更新学生基础信息失败:', error);
        throw error;
    }
};

/**
 * 获取学生背景信息
 * @param params 查询参数，包含record_id、sid和uid
 * @returns Promise<StudentBackgroundInfo>
 */
export const getStudentBackgroundInfo = async (params: StudentBackgroundInfoParams): Promise<StudentBackgroundInfo> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<StudentBackgroundInfo, StudentBackgroundInfo>(
            '/b/sme/cdc/career/detail/background_info/search',
            params
        );

        return apiData;
    } catch (error) {
        console.error('获取学生背景信息失败:', error);
        throw error;
    }
};

/**
 * 更新学生背景信息
 * @param params 更新参数，包含record_id、sid、background_info_id等字段
 * @returns Promise<UpdateStudentBackgroundInfoResponse>
 */
export const updateStudentBackgroundInfo = async (
    params: UpdateStudentBackgroundInfoParams
): Promise<UpdateStudentBackgroundInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<UpdateStudentBackgroundInfoResponse, UpdateStudentBackgroundInfoResponse>(
            '/b/sme/cdc/career/detail/background_info/update',
            params
        );

        return apiData;
    } catch (error) {
        console.error('更新学生背景信息失败:', error);
        throw error;
    }
};

/**
 * 获取学生活动信息
 * @param params 查询参数，包含record_id、sid、page和limit
 * @returns Promise<StudentActivityInfoResponse>
 */
export const getStudentActivityInfo = async (
    params: StudentActivityInfoParams
): Promise<StudentActivityInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<StudentActivityInfoResponse, StudentActivityInfoResponse>(
            '/b/sme/cdc/career/detail/activity_info/search',
            params
        );

        return apiData;
    } catch (error) {
        console.error('获取学生活动信息失败:', error);
        throw error;
    }
};

/**
 * 更新学生活动信息
 * @param params 更新参数，包含record_id、sid、activity_info_id等字段
 * @returns Promise<UpdateStudentActivityInfoResponse>
 */
export const updateStudentActivityInfo = async (
    params: UpdateStudentActivityInfoParams
): Promise<UpdateStudentActivityInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<UpdateStudentActivityInfoResponse, UpdateStudentActivityInfoResponse>(
            '/b/sme/cdc/career/detail/activity_info/cell/update',
            params
        );

        return apiData;
    } catch (error) {
        console.error('更新学生活动信息失败:', error);
        throw error;
    }
};

/**
 * 添加学生活动信息
 * @param params 添加参数，包含record_id、sid、activity_time等字段
 * @returns Promise<AddStudentActivityInfoResponse>
 */
export const addStudentActivityInfo = async (
    params: AddStudentActivityInfoParams
): Promise<AddStudentActivityInfoResponse> => {
    try {
        const apiData = await service.post<AddStudentActivityInfoResponse, AddStudentActivityInfoResponse>(
            '/b/sme/cdc/career/detail/activity_info/cell/add',
            params
        );

        return apiData;
    } catch (error) {
        console.error('添加学生活动信息失败:', error);
        throw error;
    }
};

/**
 * 创建学生活动信息
 * @param params 创建参数，包含record_id、sid、activity_time等字段
 * @returns Promise<CreateStudentActivityInfoResponse>
 */
export const createStudentActivityInfo = async (
    params: CreateStudentActivityInfoParams
): Promise<CreateStudentActivityInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        // 拦截器会自动添加uid参数
        const apiData = await service.post<CreateStudentActivityInfoResponse, CreateStudentActivityInfoResponse>(
            '/b/sme/cdc/career/detail/activity_info/cell/create',
            params
        );

        return apiData;
    } catch (error) {
        console.error('创建学生活动信息失败:', error);
        throw error;
    }
};

/**
 * 删除学生活动信息
 * @param params 删除参数，包含uid、sid、record_id、activity_info_id字段
 * @returns Promise<DeleteStudentActivityInfoResponse>
 */
export const deleteStudentActivityInfo = async (
    params: DeleteStudentActivityInfoParams
): Promise<DeleteStudentActivityInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<DeleteStudentActivityInfoResponse, DeleteStudentActivityInfoResponse>(
            '/b/sme/cdc/career/detail/activity_info/cell/delete',
            params
        );

        return apiData;
    } catch (error) {
        console.error('删除学生活动信息失败:', error);
        throw error;
    }
};

/**
 * 获取学生实习信息
 * @param params 查询参数，包含record_id、sid、page和limit
 * @returns Promise<StudentInternshipInfoResponse>
 */
export const getStudentInternshipInfo = async (
    params: StudentInternshipInfoParams
): Promise<StudentInternshipInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<StudentInternshipInfoResponse, StudentInternshipInfoResponse>(
            '/b/sme/cdc/career/detail/internship_info/search',
            params
        );

        return apiData;
    } catch (error) {
        console.error('获取学生实习信息失败:', error);
        throw error;
    }
};

/**
 * 更新学生实习信息
 * @param params 更新参数，包含record_id、sid、internship_info_id等字段
 * @returns Promise<UpdateStudentInternshipInfoResponse>
 */
export const updateStudentInternshipInfo = async (
    params: UpdateStudentInternshipInfoParams
): Promise<UpdateStudentInternshipInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<UpdateStudentInternshipInfoResponse, UpdateStudentInternshipInfoResponse>(
            '/b/sme/cdc/career/detail/internship_info/cell/update',
            params
        );

        return apiData;
    } catch (error) {
        console.error('更新学生实习信息失败:', error);
        throw error;
    }
};

/**
 * 创建学生实习信息
 * @param params 创建参数，包含record_id、sid、start_time等字段
 * @returns Promise<CreateStudentInternshipInfoResponse>
 */
export const createStudentInternshipInfo = async (
    params: CreateStudentInternshipInfoParams
): Promise<CreateStudentInternshipInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        // 拦截器会自动添加uid参数
        const apiData = await service.post<CreateStudentInternshipInfoResponse, CreateStudentInternshipInfoResponse>(
            '/b/sme/cdc/career/detail/internship_info/cell/create',
            params
        );

        return apiData;
    } catch (error) {
        console.error('创建学生实习信息失败:', error);
        throw error;
    }
};

/**
 * 删除学生实习信息
 * @param params 删除参数，包含record_id、sid和internship_info_id
 * @returns Promise<DeleteStudentInternshipInfoResponse>
 */
export const deleteStudentInternshipInfo = async (
    params: DeleteStudentInternshipInfoParams
): Promise<DeleteStudentInternshipInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        // 拦截器会自动添加uid参数
        const apiData = await service.post<DeleteStudentInternshipInfoResponse, DeleteStudentInternshipInfoResponse>(
            '/b/sme/cdc/career/detail/internship_info/cell/delete',
            params
        );

        return apiData;
    } catch (error) {
        console.error('删除学生实习信息失败:', error);
        throw error;
    }
};

/**
 * 获取学生工作信息
 * @param params 查询参数，包含record_id、sid、page和limit
 * @returns Promise<StudentOfferInfoResponse>
 */
export const getStudentOfferInfo = async (params: StudentOfferInfoParams): Promise<StudentOfferInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<StudentOfferInfoResponse, StudentOfferInfoResponse>(
            '/b/sme/cdc/career/detail/offer_info/search',
            params
        );

        return apiData;
    } catch (error) {
        console.error('获取学生工作信息失败:', error);
        throw error;
    }
};

/**
 * 获取学生工作信息详情
 * @param params 查询参数，包含record_id、sid和offer_info_id
 * @returns Promise<StudentOfferDetail>
 */
export const getStudentOfferDetail = async (params: StudentOfferDetailParams): Promise<StudentOfferDetail> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<StudentOfferDetail, StudentOfferDetail>(
            '/b/sme/cdc/career/detail/offer_info/cell/search',
            params
        );

        return apiData;
    } catch (error) {
        console.error('获取学生工作信息详情失败:', error);
        throw error;
    }
};

/**
 * 创建学生工作信息
 * @param params 创建参数，包含工作信息的全部字段
 * @returns Promise<CreateStudentOfferInfoResponse>
 */
export const createStudentOfferInfo = async (params: any): Promise<any> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<any, any>('/b/sme/cdc/career/detail/offer_info/cell/create', params);

        return apiData;
    } catch (error) {
        console.error('创建学生工作信息失败:', error);
        throw error;
    }
};

/**
 * 删除学生工作信息
 * @param params 删除参数，包含record_id、sid和offer_info_id
 * @returns Promise<DeleteStudentOfferInfoResponse>
 */
export const deleteStudentOfferInfo = async (
    params: DeleteStudentOfferInfoParams
): Promise<DeleteStudentOfferInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<DeleteStudentOfferInfoResponse, DeleteStudentOfferInfoResponse>(
            '/b/sme/cdc/career/detail/offer_info/cell/delete',
            params
        );

        return apiData;
    } catch (error) {
        console.error('删除学生工作信息失败:', error);
        throw error;
    }
};

/**
 * 更新学生工作信息
 * @param params 更新参数，包含工作信息的全部字段
 * @returns Promise<UpdateStudentOfferInfoResponse>
 */
export const updateStudentOfferInfo = async (
    params: UpdateStudentOfferInfoParams
): Promise<UpdateStudentOfferInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<UpdateStudentOfferInfoResponse, UpdateStudentOfferInfoResponse>(
            '/b/sme/cdc/career/detail/offer_info/cell/update',
            params
        );

        return apiData;
    } catch (error) {
        console.error('更新学生工作信息失败:', error);
        throw error;
    }
};

/**
 * 获取学生关键信息
 * @param params 查询参数，包含record_id、sid和key_info_id
 * @returns Promise<StudentKeyInfo>
 */
export const getStudentKeyInfo = async (params: StudentKeyInfoParams): Promise<StudentKeyInfo> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<StudentKeyInfo, StudentKeyInfo>(
            '/b/sme/cdc/career/detail/key_info/search',
            params
        );

        return apiData;
    } catch (error) {
        console.error('获取学生关键信息失败:', error);
        throw error;
    }
};

/**
 * 更新学生关键信息
 * @param params 更新参数，包含关键信息的全部字段
 * @returns Promise<UpdateStudentKeyInfoResponse>
 */
export const updateStudentKeyInfo = async (
    params: UpdateStudentKeyInfoParams
): Promise<UpdateStudentKeyInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<UpdateStudentKeyInfoResponse, UpdateStudentKeyInfoResponse>(
            '/b/sme/cdc/career/detail/key_info/update',
            params
        );

        return apiData;
    } catch (error) {
        console.error('更新学生关键信息失败:', error);
        throw error;
    }
};

/**
 * 获取特需生类型列表
 * @returns Promise<string[]> 返回特需生类型列表
 */
export const getSpecialAttentionTypes = async (): Promise<string[]> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<SpecialAttentionResponse, SpecialAttentionResponse>(
            '/b/sme/cdc/career/box/apecial_attention/search',
            {}
        );

        // 处理响应数据，确保返回一个字符串数组
        if (Array.isArray(apiData)) {
            return apiData;
        } else if (apiData && typeof apiData === 'object') {
            // 如果是对象，尝试获取其中的数组
            for (const key in apiData) {
                if (Array.isArray(apiData[key])) {
                    return apiData[key];
                }
            }
        }

        // 如果无法获取数组，返回空数组
        return [];
    } catch (error) {
        console.error('获取特需生类型列表失败:', error);
        // 出错时返回空数组
        return [];
    }
};

/**
 * 获取联系家长选项列表
 * @returns Promise<string[]> 返回联系家长选项列表
 */
export const getParentsContactedOptions = async (): Promise<string[]> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<ParentsContactedResponse, ParentsContactedResponse>(
            '/b/sme/cdc/career/box/parents_contacted/search',
            {}
        );

        // 处理响应数据，确保返回一个字符串数组
        if (Array.isArray(apiData)) {
            return apiData;
        } else if (apiData && typeof apiData === 'object') {
            // 如果是对象，尝试获取其中的数组
            for (const key in apiData) {
                if (Array.isArray(apiData[key])) {
                    return apiData[key];
                }
            }
        }

        // 如果无法获取数组，返回空数组
        return [];
    } catch (error) {
        console.error('获取联系家长选项列表失败:', error);
        // 出错时返回空数组
        return [];
    }
};

/**
 * 获取省厅系统填报选项列表
 * @returns Promise<string[]> 返回省厅系统填报选项列表
 */
export const getProvinceSystemReportOptions = async (): Promise<string[]> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<ProvinceSystemReportResponse, ProvinceSystemReportResponse>(
            '/b/sme/cdc/career/box/province_system_report/search',
            {}
        );

        // 处理响应数据，确保返回一个字符串数组
        if (Array.isArray(apiData)) {
            return apiData;
        } else if (apiData && typeof apiData === 'object') {
            // 如果是对象，尝试获取其中的数组
            for (const key in apiData) {
                if (Array.isArray(apiData[key])) {
                    return apiData[key];
                }
            }
        }

        // 如果无法获取数组，返回空数组
        return [];
    } catch (error) {
        console.error('获取省厅系统填报选项列表失败:', error);
        // 出错时返回空数组
        return [];
    }
};

/**
 * 获取毕业生登记表填报选项列表
 * @returns Promise<string[]> 返回毕业生登记表填报选项列表
 */
export const getGraduateRegisteReportOptions = async (): Promise<string[]> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<GraduateRegisteReportResponse, GraduateRegisteReportResponse>(
            '/b/sme/cdc/career/box/graduate_registe_report/search',
            {}
        );

        // 处理响应数据，确保返回一个字符串数组
        if (Array.isArray(apiData)) {
            return apiData;
        } else if (apiData && typeof apiData === 'object') {
            // 如果是对象，尝试获取其中的数组
            for (const key in apiData) {
                if (Array.isArray(apiData[key])) {
                    return apiData[key];
                }
            }
        }

        // 如果无法获取数组，返回空数组
        return [];
    } catch (error) {
        console.error('获取毕业生登记表填报选项列表失败:', error);
        // 出错时返回空数组
        return [];
    }
};

/**
 * 获取毕业计划选项列表
 * @returns Promise<string[]> 返回毕业计划选项列表
 */
export const getGraduatePlanOptions = async (): Promise<string[]> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<GraduatePlanResponse, GraduatePlanResponse>(
            '/b/sme/cdc/career/box/graduate_plan/search',
            {}
        );

        // 处理响应数据，确保返回一个字符串数组
        if (Array.isArray(apiData)) {
            return apiData;
        } else if (apiData && typeof apiData === 'object') {
            // 如果是对象，尝试获取其中的数组
            for (const key in apiData) {
                if (Array.isArray(apiData[key])) {
                    return apiData[key];
                }
            }
        }

        // 如果无法获取数组，返回空数组
        return [];
    } catch (error) {
        console.error('获取毕业计划选项列表失败:', error);
        // 出错时返回空数组
        return [];
    }
};

/**
 * 获取中文水平选项列表
 * @returns Promise<string[]> 返回中文水平选项列表
 */
export const getChineseLevelOptions = async (): Promise<string[]> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<ChineseLevelResponse, ChineseLevelResponse>(
            '/b/sme/cdc/career/box/chinese_level/search',
            {}
        );

        // 处理响应数据，确保返回一个字符串数组
        if (Array.isArray(apiData)) {
            return apiData;
        } else if (apiData && typeof apiData === 'object') {
            // 如果是对象，尝试获取其中的数组
            for (const key in apiData) {
                if (Array.isArray(apiData[key])) {
                    return apiData[key];
                }
            }
        }

        // 如果无法获取数组，返回空数组
        return [];
    } catch (error) {
        console.error('获取中文水平选项列表失败:', error);
        // 出错时返回空数组
        return [];
    }
};

/**
 * 获取记录类型选项列表
 * @returns Promise<string[]> 返回记录类型选项列表
 */
export const getRecordTypeOptions = async (): Promise<string[]> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<RecordTypeResponse, RecordTypeResponse>(
            '/b/sme/cdc/career/box/record_type/search',
            {}
        );

        // 处理响应数据，确保返回一个字符串数组
        if (Array.isArray(apiData)) {
            return apiData;
        } else if (apiData && typeof apiData === 'object') {
            // 如果是对象，尝试获取其中的数组
            for (const key in apiData) {
                if (Array.isArray(apiData[key])) {
                    return apiData[key];
                }
            }
        }

        // 如果无法获取数组，返回空数组
        return [];
    } catch (error) {
        console.error('获取记录类型选项列表失败:', error);
        // 出错时返回空数组
        return [];
    }
};

/**
 * 获取学籍状态选项列表
 * @returns Promise<string[]> 返回学籍状态选项列表
 */
export const getEnrollmentStatusOptions = async (): Promise<string[]> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<EnrollmentStatusResponse, EnrollmentStatusResponse>(
            '/b/sme/cdc/career/box/enrollment_status/search',
            {}
        );

        // 处理响应数据，确保返回一个字符串数组
        if (Array.isArray(apiData)) {
            return apiData;
        } else if (apiData && typeof apiData === 'object') {
            // 如果是对象，尝试获取其中的数组
            for (const key in apiData) {
                if (Array.isArray(apiData[key])) {
                    return apiData[key];
                }
            }
        }

        // 如果无法获取数组，返回空数组
        return [];
    } catch (error) {
        console.error('获取学籍状态选项列表失败:', error);
        // 出错时返回空数组
        return [];
    }
};

/**
 * 获取招生类型选项列表
 * @returns Promise<string[]> 返回招生类型选项列表
 */
export const getEnrollmentTypeOptions = async (): Promise<string[]> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<EnrollmentTypeResponse, EnrollmentTypeResponse>(
            '/b/sme/cdc/career/box/enrollment_type/search',
            {}
        );

        // 处理响应数据，确保返回一个字符串数组
        if (Array.isArray(apiData)) {
            return apiData;
        } else if (apiData && typeof apiData === 'object') {
            // 如果是对象，尝试获取其中的数组
            for (const key in apiData) {
                if (Array.isArray(apiData[key])) {
                    return apiData[key];
                }
            }
        }

        // 如果无法获取数组，返回空数组
        return [];
    } catch (error) {
        console.error('获取招生类型选项列表失败:', error);
        // 出错时返回空数组
        return [];
    }
};

/**
 * 获取顾问选项列表
 * @returns Promise<string[]> 返回顾问选项列表
 */
export const getAdvisorOptions = async (): Promise<string[]> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<AdvisorResponse, AdvisorResponse>(
            '/b/sme/cdc/career/box/advisor/search',
            {}
        );

        // 处理响应数据，确保返回一个字符串数组
        if (Array.isArray(apiData)) {
            return apiData;
        } else if (apiData && typeof apiData === 'object') {
            // 如果是对象，尝试获取其中的数组
            for (const key in apiData) {
                if (Array.isArray(apiData[key])) {
                    return apiData[key];
                }
            }
        }

        // 如果无法获取数组，返回空数组
        return [];
    } catch (error) {
        console.error('获取顾问选项列表失败:', error);
        // 出错时返回空数组
        return [];
    }
};

/**
 * 获取困难类型选项列表
 * @returns Promise<string[]> 返回困难类型选项列表
 */
export const getDifficultyTypeOptions = async (): Promise<string[]> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<DifficultyTypeResponse, DifficultyTypeResponse>(
            '/b/sme/cdc/career/box/difficulty_type/search',
            {}
        );

        // 处理响应数据，确保返回一个字符串数组
        if (Array.isArray(apiData)) {
            return apiData;
        } else if (apiData && typeof apiData === 'object') {
            // 如果是对象，尝试获取其中的数组
            for (const key in apiData) {
                if (Array.isArray(apiData[key])) {
                    return apiData[key];
                }
            }
        }

        // 如果无法获取数组，返回空数组
        return [];
    } catch (error) {
        console.error('获取困难类型选项列表失败:', error);
        // 出错时返回空数组
        return [];
    }
};

/**
 * 获取Offer状态选项列表
 * @returns Promise<string[]> 返回Offer状态选项列表
 */
export const getOfferStatusOptions = async (): Promise<string[]> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<OfferStatusResponse, OfferStatusResponse>(
            '/b/sme/cdc/career/box/offer_status/search',
            {}
        );

        // 处理响应数据，确保返回一个字符串数组
        if (Array.isArray(apiData)) {
            return apiData;
        } else if (apiData && typeof apiData === 'object') {
            // 如果是对象，尝试获取其中的数组
            for (const key in apiData) {
                if (Array.isArray(apiData[key])) {
                    return apiData[key];
                }
            }
        }

        // 如果无法获取数组，返回空数组
        return [];
    } catch (error) {
        console.error('获取Offer状态选项列表失败:', error);
        // 出错时返回空数组
        return [];
    }
};

/**
 * 获取Offer类型选项列表
 * @returns Promise<string[]> 返回Offer类型选项列表
 */
export const getOfferTypeOptions = async (): Promise<string[]> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<OfferTypeResponse, OfferTypeResponse>(
            '/b/sme/cdc/career/box/offer_type/search',
            {}
        );

        // 处理响应数据，确保返回一个字符串数组
        if (Array.isArray(apiData)) {
            return apiData;
        } else if (apiData && typeof apiData === 'object') {
            // 如果是对象，尝试获取其中的数组
            for (const key in apiData) {
                if (Array.isArray(apiData[key])) {
                    return apiData[key];
                }
            }
        }

        // 如果无法获取数组，返回空数组
        return [];
    } catch (error) {
        console.error('获取Offer类型选项列表失败:', error);
        // 出错时返回空数组
        return [];
    }
};

/**
 * 获取项目类型选项列表
 * @returns Promise<string[]> 返回项目类型选项列表
 */
export const getProjectTypeOptions = async (): Promise<string[]> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<ProjectTypeResponse, ProjectTypeResponse>(
            '/b/sme/cdc/career/box/project_type/search',
            {}
        );

        // 处理响应数据，确保返回一个字符串数组
        if (Array.isArray(apiData)) {
            return apiData;
        } else if (apiData && typeof apiData === 'object') {
            // 如果是对象，尝试获取其中的数组
            for (const key in apiData) {
                if (Array.isArray(apiData[key])) {
                    return apiData[key];
                }
            }
        }

        // 如果无法获取数组，返回空数组
        return [];
    } catch (error) {
        console.error('获取项目类型选项列表失败:', error);
        // 出错时返回空数组
        return [];
    }
};

/**
 * 模糊搜索Offer地区
 * @param queryKey 搜索关键词
 * @returns Promise<string[]> 返回匹配的地区列表
 */
export const fuzzySearchOfferArea = async (queryKey: string): Promise<string[]> => {
    try {
        // 发送请求并等待响应
        const response = await service.post<{ code: number; msg: string; data: string[] }, string[]>(
            '/b/sme/cdc/career/detail/offer_info/area/fuzzy',
            { query_key: queryKey }
        );

        return response;
    } catch (error) {
        console.error('模糊搜索Offer地区失败:', error);
        return []; // 返回空数组而不是抛出错误，以便UI能够优雅地处理
    }
};

/**
 * 模糊搜索企业/学校名称
 * @param queryKey 搜索关键词
 * @returns Promise<string[]> 返回匹配的企业/学校列表
 */
export const fuzzySearchOfferSchool = async (queryKey: string): Promise<string[]> => {
    try {
        // 发送请求并等待响应
        const response = await service.post<{ code: number; msg: string; data: string[] }, string[]>(
            '/b/sme/cdc/career/detail/offer_info/school/fuzzy',
            { query_key: queryKey }
        );

        return response;
    } catch (error) {
        console.error('模糊搜索企业/学校名称失败:', error);
        return []; // 返回空数组而不是抛出错误，以便UI能够优雅地处理
    }
};

/**
 * 模糊搜索职位/项目名称
 * @param queryKey 搜索关键词
 * @returns Promise<string[]> 返回匹配的职位/项目列表
 */
export const fuzzySearchOfferProgram = async (queryKey: string): Promise<string[]> => {
    try {
        // 发送请求并等待响应
        const response = await service.post<{ code: number; msg: string; data: string[] }, string[]>(
            '/b/sme/cdc/career/detail/offer_info/program/fuzzy',
            { query_key: queryKey }
        );

        return response;
    } catch (error) {
        console.error('模糊搜索职位/项目名称失败:', error);
        return []; // 返回空数组而不是抛出错误，以便UI能够优雅地处理
    }
};

/**
 * 获取学生毕业信息
 * @param params 查询参数，包含record_id、sid和graduate_info_id
 * @returns Promise<StudentGraduateInfo>
 */
export const getStudentGraduateInfo = async (params: StudentGraduateInfoParams): Promise<StudentGraduateInfo> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<StudentGraduateInfo, StudentGraduateInfo>(
            '/b/sme/cdc/career/detail/graduate_info/search',
            params
        );

        return apiData;
    } catch (error) {
        console.error('获取学生毕业信息失败:', error);
        throw error;
    }
};

/**
 * 更新学生毕业信息
 * @param params 更新参数，包含毕业信息的全部字段
 * @returns Promise<UpdateStudentGraduateInfoResponse>
 */
export const updateStudentGraduateInfo = async (
    params: UpdateStudentGraduateInfoParams
): Promise<UpdateStudentGraduateInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<UpdateStudentGraduateInfoResponse, UpdateStudentGraduateInfoResponse>(
            '/b/sme/cdc/career/detail/graduate_info/update',
            params
        );

        return apiData;
    } catch (error) {
        console.error('更新学生毕业信息失败:', error);
        throw error;
    }
};

/**
 * 获取学生CDC记录
 * @param params 查询参数，包含record_id、sid、page和limit
 * @returns Promise<StudentDailyInfoResponse>
 */
export const getStudentDailyInfo = async (params: StudentDailyInfoParams): Promise<StudentDailyInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<StudentDailyInfoResponse, StudentDailyInfoResponse>(
            '/b/sme/cdc/career/detail/daily_info/search',
            params
        );

        return apiData;
    } catch (error) {
        console.error('获取学生CDC记录失败:', error);
        throw error;
    }
};

/**
 * 添加学生CDC记录
 * @param params 添加参数，包含CDC记录的全部字段
 * @returns Promise<AddStudentDailyInfoResponse>
 */
export const addStudentDailyInfo = async (params: AddStudentDailyInfoParams): Promise<AddStudentDailyInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<AddStudentDailyInfoResponse, AddStudentDailyInfoResponse>(
            '/b/sme/cdc/career/detail/daily_info/cell/create',
            params
        );

        return apiData;
    } catch (error) {
        console.error('添加学生CDC记录失败:', error);
        throw error;
    }
};

/**
 * 删除学生CDC记录
 * @param params 删除参数，包含record_id、sid和daily_info_id
 * @returns Promise<DeleteStudentDailyInfoResponse>
 */
export const deleteStudentDailyInfo = async (
    params: DeleteStudentDailyInfoParams
): Promise<DeleteStudentDailyInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<DeleteStudentDailyInfoResponse, DeleteStudentDailyInfoResponse>(
            '/b/sme/cdc/career/detail/daily_info/cell/delete',
            params
        );

        return apiData;
    } catch (error) {
        console.error('删除学生CDC记录失败:', error);
        throw error;
    }
};

/**
 * 更新学生CDC记录
 * @param params 更新参数，包含CDC记录的全部字段
 * @returns Promise<UpdateStudentDailyInfoResponse>
 */
export const updateStudentDailyInfo = async (
    params: UpdateStudentDailyInfoParams
): Promise<UpdateStudentDailyInfoResponse> => {
    try {
        // 发送请求并等待响应
        // 拦截器会自动从 { code, msg, data } 中提取 data 部分
        const apiData = await service.post<UpdateStudentDailyInfoResponse, UpdateStudentDailyInfoResponse>(
            '/b/sme/cdc/career/detail/daily_info/cell/update',
            params
        );

        return apiData;
    } catch (error) {
        console.error('更新学生CDC记录失败:', error);
        throw error;
    }
};

/**
 * 导入学生基础信息
 * @param file 要上传的Excel文件
 * @returns Promise<any> 返回导入结果
 */
export const importStudentBaseInfo = async (file: File): Promise<any> => {
    try {
        const formData = new FormData();
        formData.append('file', file);

        const response = await service.post<any, any>(
            '/b/sme/cdc/career/student_mgt/detail/base_info/import',
            formData,
            {
                headers: {
                    'Content-Type': 'multipart/form-data'
                }
            }
        );

        return response;
    } catch (error) {
        console.error('导入学生基础信息失败:', error);
        throw error;
    }
};

/**
 * 导入学生活动信息
 * @param file 要上传的Excel文件
 * @returns Promise<any> 返回导入结果
 */
export const importStudentActivityInfo = async (file: File): Promise<any> => {
    try {
        const formData = new FormData();
        formData.append('file', file);

        const response = await service.post<any, any>(
            '/b/sme/cdc/career/student_mgt/detail/activity_info/import',
            formData,
            {
                headers: {
                    'Content-Type': 'multipart/form-data'
                }
            }
        );

        return response;
    } catch (error) {
        console.error('导入学生活动信息失败:', error);
        throw error;
    }
};

/**
 * 导入学生实习信息
 * @param file 要上传的Excel文件
 * @returns Promise<any> 返回导入结果
 */
export const importStudentInternshipInfo = async (file: File): Promise<any> => {
    try {
        const formData = new FormData();
        formData.append('file', file);

        const response = await service.post<any, any>(
            '/b/sme/cdc/career/student_mgt/detail/internship_info/import',
            formData,
            {
                headers: {
                    'Content-Type': 'multipart/form-data'
                }
            }
        );

        return response;
    } catch (error) {
        console.error('导入学生实习信息失败:', error);
        throw error;
    }
};

/**
 * 模糊搜索专业
 * @param queryKey 搜索关键词
 * @returns Promise<string[]> 返回匹配的专业列表
 */
export const fuzzySearchMajor = async (queryKey: string): Promise<string[]> => {
    try {
        // 发送请求并等待响应
        const response = await service.post<{ code: number; msg: string; data: string[] }, string[]>(
            '/b/sme/cdc/career/student_mgt/main/major/search',
            { query_key: queryKey }
        );

        return response;
    } catch (error) {
        console.error('模糊搜索专业失败:', error);
        return []; // 返回空数组而不是抛出错误，以便UI能够优雅地处理
    }
};

import axios from 'axios';

/**
 * 下载学生信息文件 - 直接使用axios而非封装的service
 * @param params 查询参数，与搜索参数一致
 * @returns void
 */
export const downloadStudentFile = async (params: StudentSearchParams): Promise<void> => {
    try {
        // 准备请求参数，去除空值
        const requestParams: Record<string, any> = {};

        // 获取当前登录用户ID
        const uid = localStorage.getItem('uid') || '';
        requestParams.uid = uid;

        // 获取token
        const token = localStorage.getItem('token') || '';

        // 添加其他非空参数
        Object.entries(params).forEach(([key, value]) => {
            if (value !== undefined && value !== null && value !== '') {
                requestParams[key] = value;
            }
        });

        console.log('下载请求参数:', requestParams);

        const response = await axios({
            method: 'post',
            url: '/b/sme/cdc/career/main/download',
            data: requestParams,
            responseType: 'blob',
            headers: {
                'Content-Type': 'application/json;charset=utf-8',
                Authorization: token ? `Bearer ${token}` : ''
            }
        });

        console.log('响应头:', response.headers);

        // 获取文件名
        let filename = '学生信息.xlsx';
        const contentDisposition = response.headers['content-disposition'];
        if (contentDisposition) {
            const filenameMatch = contentDisposition.match(/filename[^;=\n]*=((['"]).*)\2|[^;\n]*/);
            if (filenameMatch && filenameMatch[1]) {
                filename = filenameMatch[1].replace(/['"]*/g, '');
            }
        } else {
            // 如果没有content-disposition头，使用默认文件名加时间戳
            filename = `学生信息_${new Date().toISOString().split('T')[0]}.xlsx`;
        }

        // 获取内容类型
        const contentType = response.headers['content-type'] || 'application/octet-stream';
        console.log('内容类型:', contentType);

        // 创建 Blob URL
        const blob = new Blob([response.data], { type: contentType });
        const url = window.URL.createObjectURL(blob);

        // 创建一个隐藏的a标签触发下载
        const a = document.createElement('a');
        a.style.display = 'none';
        a.href = url;
        a.download = filename;

        // 添加到body并触发点击
        document.body.appendChild(a);
        a.click();

        // 清理
        window.URL.revokeObjectURL(url);
        document.body.removeChild(a);

        console.log('文件下载成功:', filename);
    } catch (error) {
        console.error('下载学生信息文件失败:', error);
        throw error;
    }
};
